# To change this template, choose Tools | Templates
# and open the template in the editor.

require 'utility/utility'


class Testing
 def Testing.comparate(indice_utente, soil,ows=1,owsc=1,owscn=1,orr=1,oer=1,orl=1,oqr=1)
  responso= Util.parser()
   utenti= responso[0]
  m1= Util.users_to_matrix(utenti,0)
  m2= Util.users_to_matrix(utenti,0)

  u= utenti[indice_utente]

  uy= u.no_context
  sim= []
  cos_sim= []
  s= CosineSim.new()
  j= Jaccard.new()

  m1.each{|x|
    sim.push(j.ind_jac(x, uy, 0))
  }

  m1.each{|x|
    cos_sim.push(s.cosine_similarity(x, uy))
  }



  m11=[]
  m21=[]


  (0..m1.size-1).each{|i|
     if i==indice_utente then
      m11.push(m1[4])
    elsif (sim[i] >= soil)
      then m11.push(m1[i])
    end
  }

  (0..m2.size-1).each{|i|
    if i==indice_utente then
      m21.push(m2[4])
    elsif (sim[i] >= soil)
      then m21.push(m2[i])
    end
  }
  
  n_cos_sim= s.normalize(cos_sim) 
  
  b= Bench.new  

  print("Utente numero: ", indice_utente,"\n")
  print("<<-------------------------------->>\n")
  p 'scored weighted sum Cosine similarity'
  wss= WeightedSum.new(sim, 0.6)
  p wss.scored_weight(m2)
  p b.benchmark_coppia_ndcg(u.context_1, wss.scored_weight(m2))
  p b.benchmark_coppia_chisquare(wss.scored_weight(m2), u.context_1)
  print("<<-------------------------------->>\n")
  if ows==1 then
  p 'weighted sum jaccard'
  ws= WeightedSum.new(sim, 0.8)
  p ws.weighted_sum(m2)
  p b.benchmark_coppia_ndcg(u.context_1, ws.weighted_sum(m2))
  p b.benchmark_coppia_chisquare(ws.weighted_sum(m2), u.context_1)
  print("<<-------------------------------->>\n")
  end
  if owsc==1 then
  p 'weighted sum Cosine similarity'
  wsc= WeightedSum.new(cos_sim, 0.6)
  p wsc.weighted_sum(m2)
  p b.benchmark_coppia_ndcg(u.context_1, wsc.weighted_sum(m2))
  p b.benchmark_coppia_chisquare(wsc.weighted_sum(m2), u.context_1)
  print("<<-------------------------------->>\n")
  end
  if owscn==1 then
  p 'weighted sum Cosine similarity Normalizzata'
  wscn=WeightedSum.new(n_cos_sim, 0.6)
  p wscn.weighted_sum(m2)
  p b.benchmark_coppia_ndcg(u.context_1, wscn.weighted_sum(m2))
  p b.benchmark_coppia_chisquare(wscn.weighted_sum(m2), u.context_1)
  print("<<-------------------------------->>\n")
  end
  if orr==1 then
  p 'ridge regression'
  rr= RidgeRegression.new(m11, uy, 0.7)
  p rr.regressione(m21)
  p b.benchmark_coppia_ndcg(u.context_1, rr.regressione(m21))
  p b.benchmark_coppia_chisquare(rr.regressione(m21), u.context_1)
  print("<<-------------------------------->>\n")
  end
  if oer==1 then
  p 'exponential regression'
  er= ExponentialRegression.new(m11, uy)
  p er.regressione(m21)
  p b.benchmark_coppia_ndcg(u.context_1, er.regressione(m21))
  p b.benchmark_coppia_chisquare(er.regressione(m21), u.context_1)
  print("<<-------------------------------->>\n")
  end
  if oqr==1 then
  p 'Quadratic regression'
  qr= QuadraticRegression.new(m11,uy)
  p qr.regressione(m21)
  p b.benchmark_coppia_ndcg(u.context_1, qr.regressione(m21))
  p b.benchmark_coppia_chisquare(qr.regressione(m21), u.context_1)
  print("<<-------------------------------->>\n")
  end
  if orl==1 then
  p 'regressione lineare'
  lr= LinearRegression.new(m11,uy)
  p lr.regressione(m21)
  p b.benchmark_coppia_ndcg(u.context_1, lr.regressione(m21))
  p b.benchmark_coppia_chisquare(lr.regressione(m21), u.context_1)
  print("<<-------------------------------->>\n")
  end
  print("<<-------------------------------->>\n")
  p 'Valori reali'
  p u.context_1
  print("<<-------------------------------->>\n")
  print("<<-------------------------------->>\n")
  print("<<-------------------------------->>\n")
  print("<<-------------------------------->>\n")
  end
  def build_solution(interfaccia, opzioni,visualize)
  string_vector= ['mae','rmse','nrmse','chi','rsquare','hitrate','ndcg']
(0..2).each{|contesto|
  bench_vector = []
  responso = Util.parser()
  utenti = responso[0]
  loo= []
  (0..utenti.size-1).each{|u|
    i= Interfaces.new(utenti, utenti[u].id)
    i.prepare_data('simple',10)
    if contesto>0 then
      i.scored('cosine')
    end
    loo.push(i.scored('cosine',contesto))
  }
  (0..string_vector.size-1).each{|b|
    appo = 0
    (0..loo.size-1).each{|n|
      appo += loo[n][string_vector[b]]
    }
    bench_vector.push(string_vector[b]=>appo/(loo.size-1))
  }
  p "contesto:#{contesto+1}"
  p bench_vector
}
return [loo,bench_vector,contesto]
  end

  # Test della scored sum con cluster di dimensioni differeenti: rispettivamente 20,15,10,5
  def Testing.different_clusters(utente=0)
      responso = Util.parser()
  utenti = responso[0]
    p "<--------------------------------->"
   p "<--------------------------------->"
    p "<--------------------------------->"
     p "<--------------------------------->"
     p "Utilizzo del clusterig di dimensioni differenti"
      p "<--------------------------------->"
       p "<--------------------------------->"
p "cluster con 20 utenti"
    i= Interfaces.new(utenti, utente)
    i.prepare_data('simple',20)
   p i.scored('pearson')['predizione']
   p i.scored('pearson',1)['predizione']
   p i.scored('pearson',2)['predizione']
p "cluster con 15 utenti"
    i1= Interfaces.new(utenti, utente)
    i1.prepare_data('simple',15)
   p i1.scored('pearson')['predizione']
   p i1.scored('pearson',1)['predizione']
   p i1.scored('pearson',2)['predizione']
p "cluster con 10 utenti"
    i1= Interfaces.new(utenti, utente)
    i1.prepare_data('simple',15)
   p i1.scored('pearson')['predizione']
   p i1.scored('pearson',1)['predizione']
   p i1.scored('pearson',2)['predizione']
p "cluster con 5 utenti"
    i2= Interfaces.new(utenti, utente)
    i2.prepare_data('simple',5)
   p i2.scored('pearson')['predizione']
   p i2.scored('pearson',1)['predizione']
   p i2.scored('pearson',2)['predizione']
    p "<--------------------------------->"
   p "<--------------------------------->"
    p "<--------------------------------->"
     p "<--------------------------------->"
     p "Utilizzo del clusterig gerarchico di dimensioni differenti"
      p "<--------------------------------->"
       p "<--------------------------------->"
   p "cluster con 20 utenti"
    i= Interfaces.new(utenti, utente)
    i.prepare_data('hierarchical',20)
   p i.scored('pearson')
   p i.scored('pearson',1)
   p i.scored('pearson',2)
p "cluster con 15 utenti"
    i1= Interfaces.new(utenti, utente)
    i1.prepare_data('hierarchical',15)
   p i1.scored('pearson')
   p i1.scored('pearson',1)
   p i1.scored('pearson',2)
p "cluster con 10 utenti"
    i1= Interfaces.new(utenti, utente)
    i1.prepare_data('hierarchical',15)
   p i1.scored('pearson')
   p i1.scored('pearson',1)
   p i1.scored('pearson',2)
p "cluster con 5 utenti"
    i2= Interfaces.new(utenti, utente)
    i2.prepare_data('hierarchical',5)
   p i2.scored('pearson')
   p i2.scored('pearson',1)
   p i2.scored('pearson',2)
  end
    # Test di regressione di ridge con cluster di dimensioni differeenti: rispettivamente 20,15,10,5
  def Testing.different_clusters_ridge(utente=0)
      responso = Util.parser()
  utenti = responso[0]
    p "<--------------------------------->"
   p "<--------------------------------->"
    p "<--------------------------------->"
     p "<--------------------------------->"
     p "Utilizzo del clusterig di dimensioni differenti"
      p "<--------------------------------->"
       p "<--------------------------------->"
p "cluster con 20 utenti"
    i= Interfaces.new(utenti, utente)
    i.prepare_data('simple',20)
   p i.regressione('ridge')
   p i.regressione('ridge',1)
   p i.regressione('ridge',2)
p "cluster con 15 utenti"
    i1= Interfaces.new(utenti, utente)
    i1.prepare_data('simple',15)
   p i1.regressione('ridge')
   p i1.regressione('ridge',1)
   p i1.regressione('ridge',2)
p "cluster con 10 utenti"
    i2= Interfaces.new(utenti, utente)
    i2.prepare_data('simple',15)
   p i2.regressione('ridge')
   p i2.regressione('ridge',1)
   p i2.regressione('ridge',2)
p "cluster con 5 utenti"
    i3= Interfaces.new(utenti, utente)
    i3.prepare_data('simple',5)
   p i3.regressione('ridge')
   p i3.regressione('ridge',1)
   p i3.regressione('ridge',2)
    p "<--------------------------------->"
   p "<--------------------------------->"
    p "<--------------------------------->"
     p "<--------------------------------->"
     p "Utilizzo del clusterig gerarchico di dimensioni differenti"
      p "<--------------------------------->"
       p "<--------------------------------->"
 p "cluster con 20 utenti"
    i= Interfaces.new(utenti, utente)
    i.prepare_data('hierarchical',20)
   p i.regressione('ridge')
   p i.regressione('ridge',1)
   p i.regressione('ridge',2)
p "cluster con 15 utenti"
    i1= Interfaces.new(utenti, utente)
    i1.prepare_data('hierarchical',15)
   p i1.regressione('ridge')
   p i1.regressione('ridge',1)
   p i1.regressione('ridge',2)
p "cluster con 10 utenti"
    i2= Interfaces.new(utenti, utente)
    i2.prepare_data('hierarchical',15)
   p i2.regressione('ridge')
   p i2.regressione('ridge',1)
   p i2.regressione('ridge',2)
p "cluster con 5 utenti"
    i3= Interfaces.new(utenti, utente)
    i3.prepare_data('hierarchical',5)
   p i3.regressione('ridge')
   p i3.regressione('ridge',1)
   p i3.regressione('ridge',2)
  end
end
